using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("FriendListFrame")]
	public class FriendListFrame : MonoBehaviour
	{
		[Attribute38("FriendListFrame.NearbyPlayerUpdate")]
		public class NearbyPlayerUpdate : MonoClass
		{
			public enum ChangeType
			{
				Added,
				Removed
			}

			public ChangeType Change => method_2<ChangeType>("Change");

			public BnetPlayer Player => method_3<BnetPlayer>("Player");

			public NearbyPlayerUpdate(IntPtr address, string className)
				: base(address, className)
			{
			}

			public NearbyPlayerUpdate(IntPtr address)
				: this(address, "NearbyPlayerUpdate")
			{
			}

			public new bool Equals(object obj)
			{
				return method_11<bool>("Equals", new object[1] { obj });
			}

			public new int GetHashCode()
			{
				return method_11<int>("GetHashCode", Array.Empty<object>());
			}
		}

		[Attribute38("FriendListFrame.Me")]
		public class Me : MonoClass
		{
			public Spawner portraitRef => method_3<Spawner>("portraitRef");

			public UberText nameText => method_3<UberText>("nameText");

			public GameObject m_MedalPatch => method_3<GameObject>("m_MedalPatch");

			public TournamentMedal m_Medal => method_3<TournamentMedal>("m_Medal");

			public Me(IntPtr address, string className)
				: base(address, className)
			{
			}

			public Me(IntPtr address)
				: this(address, "Me")
			{
			}
		}

		[Attribute38("FriendListFrame.RecentOpponent")]
		public class RecentOpponent : MonoClass
		{
			public PegUIElement button => method_3<PegUIElement>("button");

			public UberText nameText => method_3<UberText>("nameText");

			public RecentOpponent(IntPtr address, string className)
				: base(address, className)
			{
			}

			public RecentOpponent(IntPtr address)
				: this(address, "RecentOpponent")
			{
			}
		}

		[Attribute38("FriendListFrame.Prefabs")]
		public class Prefabs : MonoClass
		{
			public FriendListItemHeader headerItem => method_3<FriendListItemHeader>("headerItem");

			public FriendListItemFooter footerItem => method_3<FriendListItemFooter>("footerItem");

			public FriendListNearbyPlayersHeader nearbyPlayersHeaderItem => method_3<FriendListNearbyPlayersHeader>("nearbyPlayersHeaderItem");

			public FriendListRequestFrame requestItem => method_3<FriendListRequestFrame>("requestItem");

			public FriendListCurrentGameFrame currentGameItem => method_3<FriendListCurrentGameFrame>("currentGameItem");

			public FriendListFriendFrame friendItem => method_3<FriendListFriendFrame>("friendItem");

			public FriendListNearbyPlayerFrame nearbyPlayerItem => method_3<FriendListNearbyPlayerFrame>("nearbyPlayerItem");

			public FriendListFSGFrame fsgItem => method_3<FriendListFSGFrame>("fsgItem");

			public AddFriendFrame addFriendFrame => method_3<AddFriendFrame>("addFriendFrame");

			public Prefabs(IntPtr address, string className)
				: base(address, className)
			{
			}

			public Prefabs(IntPtr address)
				: this(address, "Prefabs")
			{
			}
		}

		[Attribute38("FriendListFrame.ListInfo")]
		public class ListInfo : MonoClass
		{
			public Transform topLeft => method_3<Transform>("topLeft");

			public Transform bottomRight => method_3<Transform>("bottomRight");

			public Transform bottomRightWithScrollbar => method_3<Transform>("bottomRightWithScrollbar");

			public HeaderBackgroundInfo requestBackgroundInfo => method_3<HeaderBackgroundInfo>("requestBackgroundInfo");

			public HeaderBackgroundInfo currentGameBackgroundInfo => method_3<HeaderBackgroundInfo>("currentGameBackgroundInfo");

			public ListInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ListInfo(IntPtr address)
				: this(address, "ListInfo")
			{
			}
		}

		[Attribute38("FriendListFrame.HeaderBackgroundInfo")]
		public class HeaderBackgroundInfo : MonoClass
		{
			public Mesh mesh => method_3<Mesh>("mesh");

			public Material material => method_3<Material>("material");

			public HeaderBackgroundInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public HeaderBackgroundInfo(IntPtr address)
				: this(address, "HeaderBackgroundInfo")
			{
			}
		}

		public struct FriendListItem
		{
			public object m_item;
		}

		[Attribute38("FriendListFrame.VirtualizedFriendsListBehavior")]
		public class VirtualizedFriendsListBehavior : MonoClass
		{
			public FriendListFrame m_friendList => method_3<FriendListFrame>("m_friendList");

			public int m_cachedMaxVisibleItems => method_2<int>("m_cachedMaxVisibleItems");

			public static int MAX_FREELIST_ITEMS => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "FriendListFrame/VirtualizedFriendsListBehavior", "MAX_FREELIST_ITEMS");

			public List<MobileFriendListItem> m_freelist => method_3<Class271<MobileFriendListItem>>("m_freelist")?.method_25();

			public List<Bounds> m_boundsByType => method_3<Class250<Bounds>>("m_boundsByType")?.method_25();

			public List<MobileFriendListItem> FreeList => method_14<Class271<MobileFriendListItem>>("get_FreeList", Array.Empty<object>())?.method_25();

			public int AllItemsCount => method_11<int>("get_AllItemsCount", Array.Empty<object>());

			public int MaxVisibleItems => method_11<int>("get_MaxVisibleItems", Array.Empty<object>());

			public int MinBuffer => method_11<int>("get_MinBuffer", Array.Empty<object>());

			public int MaxAcquiredItems => method_11<int>("get_MaxAcquiredItems", Array.Empty<object>());

			public bool HasCollapsedHeaders => method_11<bool>("get_HasCollapsedHeaders", Array.Empty<object>());

			public VirtualizedFriendsListBehavior(IntPtr address, string className)
				: base(address, className)
			{
			}

			public VirtualizedFriendsListBehavior(IntPtr address)
				: this(address, "VirtualizedFriendsListBehavior")
			{
			}

			public static Bounds GetPrefabBounds(GameObject prefabGameObject)
			{
				return MonoClass.smethod_14<Bounds>(TritonHs.MainAssemblyPath, "", "VirtualizedFriendsListBehavior", "GetPrefabBounds", new object[1] { prefabGameObject });
			}

			public bool IsItemShowable(int allItemsIndex)
			{
				return method_11<bool>("IsItemShowable", new object[1] { allItemsIndex });
			}

			public Vector3 GetItemSize(int allItemsIndex)
			{
				return method_11<Vector3>("GetItemSize", new object[1] { allItemsIndex });
			}

			public void ReleaseAllItems()
			{
				method_8("ReleaseAllItems");
			}

			public void InitializeBoundsByTypeArray()
			{
				method_8("InitializeBoundsByTypeArray");
			}

			public int GetBoundsByTypeIndex(MobileFriendListItem.TypeFlags itemType)
			{
				return method_11<int>("GetBoundsByTypeIndex", new object[1] { itemType });
			}

			public Component GetPrefab(MobileFriendListItem.TypeFlags itemType)
			{
				return method_14<Component>("GetPrefab", new object[1] { itemType });
			}
		}

		public Me me => method_3<Me>("me");

		public Prefabs prefabs => method_3<Prefabs>("prefabs");

		public ListInfo listInfo => method_3<ListInfo>("listInfo");

		public TouchList items => method_3<TouchList>("items");

		public PegUIElement addFriendButton => method_3<PegUIElement>("addFriendButton");

		public PegUIElement removeFriendButton => method_3<PegUIElement>("removeFriendButton");

		public GameObject removeFriendButtonEnabledVisual => method_3<GameObject>("removeFriendButtonEnabledVisual");

		public GameObject removeFriendButtonDisabledVisual => method_3<GameObject>("removeFriendButtonDisabledVisual");

		public GameObject removeFriendButtonButtonGlow => method_3<GameObject>("removeFriendButtonButtonGlow");

		public PegUIElement rafButton => method_3<PegUIElement>("rafButton");

		public GameObject rafButtonEnabledVisual => method_3<GameObject>("rafButtonEnabledVisual");

		public GameObject rafButtonDisabledVisual => method_3<GameObject>("rafButtonDisabledVisual");

		public GameObject rafButtonButtonGlow => method_3<GameObject>("rafButtonButtonGlow");

		public GameObject rafButtonGlowBone => method_3<GameObject>("rafButtonGlowBone");

		public TouchListScrollbar scrollbar => method_3<TouchListScrollbar>("scrollbar");

		public NineSliceElement window => method_3<NineSliceElement>("window");

		public PegUIElement fsgButton => method_3<PegUIElement>("fsgButton");

		public GameObject fsgButtonButtonGlow => method_3<GameObject>("fsgButtonButtonGlow");

		public GameObject portraitBackground => method_3<GameObject>("portraitBackground");

		public Material unrankedBackground => method_3<Material>("unrankedBackground");

		public Material rankedBackground => method_3<Material>("rankedBackground");

		public GameObject innerShadow => method_3<GameObject>("innerShadow");

		public GameObject outerShadow => method_3<GameObject>("outerShadow");

		public GameObject temporaryAccountPaper => method_3<GameObject>("temporaryAccountPaper");

		public GameObject temporaryAccountCover => method_3<GameObject>("temporaryAccountCover");

		public GameObject temporaryAccountDrawingBone => method_3<GameObject>("temporaryAccountDrawingBone");

		public GameObject temporaryAccountDrawing => method_3<GameObject>("temporaryAccountDrawing");

		public UIBButton temporaryAccountSignUpButton => method_3<UIBButton>("temporaryAccountSignUpButton");

		public PegUIElement flyoutMenuButton => method_3<PegUIElement>("flyoutMenuButton");

		public GameObject flyoutMenu => method_3<GameObject>("flyoutMenu");

		public float flyoutMiddleFrameScaleOffsetForFSG => method_2<float>("flyoutMiddleFrameScaleOffsetForFSG");

		public float flyoutShadowScaleOffsetForFSG => method_2<float>("flyoutShadowScaleOffsetForFSG");

		public GameObject flyoutMiddleFrame => method_3<GameObject>("flyoutMiddleFrame");

		public GameObject flyoutMiddleShadow => method_3<GameObject>("flyoutMiddleShadow");

		public MultiSliceElement flyoutFrameContainer => method_3<MultiSliceElement>("flyoutFrameContainer");

		public MultiSliceElement flyoutShadowContainer => method_3<MultiSliceElement>("flyoutShadowContainer");

		public HighlightState flyoutButtonGlow => method_3<HighlightState>("flyoutButtonGlow");

		public PlayerPortrait myPortrait => method_3<PlayerPortrait>("myPortrait");

		public AddFriendFrame m_addFriendFrame => method_3<AddFriendFrame>("m_addFriendFrame");

		public AlertPopup m_removeFriendPopup => method_3<AlertPopup>("m_removeFriendPopup");

		public Camera m_itemsCamera => method_3<Camera>("m_itemsCamera");

		public bool m_editFriendsMode => method_2<bool>("m_editFriendsMode");

		public BnetPlayer m_friendToRemove => method_3<BnetPlayer>("m_friendToRemove");

		public bool m_flyoutOpen => method_2<bool>("m_flyoutOpen");

		public bool m_patronStrangersHidden => method_2<bool>("m_patronStrangersHidden");

		public static int PatronCountHardLimit => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "FriendListFrame", "PatronCountHardLimit");

		public List<NearbyPlayerUpdate> m_nearbyPlayerUpdates => method_3<Class271<NearbyPlayerUpdate>>("m_nearbyPlayerUpdates")?.method_25();

		public BnetPlayerChangelist m_playersChangeList => method_3<BnetPlayerChangelist>("m_playersChangeList");

		public float m_lastNearbyPlayersUpdate => method_2<float>("m_lastNearbyPlayersUpdate");

		public bool m_nearbyPlayersNeedUpdate => method_2<bool>("m_nearbyPlayersNeedUpdate");

		public static float NEARBY_PLAYERS_UPDATE_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "FriendListFrame", "NEARBY_PLAYERS_UPDATE_TIME");

		public List<GameObject> m_ignoreObjectsForWorldBound => method_3<Class271<GameObject>>("m_ignoreObjectsForWorldBound")?.method_25();

		public bool m_isRAFButtonEnabled => method_2<bool>("m_isRAFButtonEnabled");

		public bool m_isFSGButtonEnabled => method_2<bool>("m_isFSGButtonEnabled");

		public List<FriendListItem> m_allItems => method_3<Class270<FriendListItem>>("m_allItems")?.method_25();

		public VirtualizedFriendsListBehavior m_longListBehavior => method_3<VirtualizedFriendsListBehavior>("m_longListBehavior");

		public Dictionary<MobileFriendListItem.TypeFlags, FriendListItemHeader> m_headers => method_3<Class253<MobileFriendListItem.TypeFlags, FriendListItemHeader>>("m_headers")?.method_25();

		public BnetPlayer SelectedPlayer => method_14<BnetPlayer>("get_SelectedPlayer", Array.Empty<object>());

		public bool ShowingAddFriendFrame => method_11<bool>("get_ShowingAddFriendFrame", Array.Empty<object>());

		public bool IsInEditMode => method_11<bool>("get_IsInEditMode", Array.Empty<object>());

		public bool IsFlyoutOpen => method_11<bool>("get_IsFlyoutOpen", Array.Empty<object>());

		public FriendListFrame(IntPtr address, string className)
			: base(address, className)
		{
		}

		public FriendListFrame(IntPtr address)
			: this(address, "FriendListFrame")
		{
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Update()
		{
			method_8("Update");
		}

		public void OnEnable()
		{
			method_8("OnEnable");
		}

		public void SetWorldRect(float x, float y, float width, float height)
		{
			method_8("SetWorldRect", x, y, width, height);
		}

		public void SetWorldPosition(float x, float y)
		{
			method_9("SetWorldPosition", new Class276.Enum20[2]
			{
				Class276.Enum20.R4,
				Class276.Enum20.R4
			}, x, y);
		}

		public void SetWorldPosition(Vector3 pos)
		{
			method_9("SetWorldPosition", new Class276.Enum20[1] { Class276.Enum20.ValueType }, pos);
		}

		public void SetWorldHeight(float height)
		{
			method_8("SetWorldHeight", height);
		}

		public void ShowAddFriendFrame(BnetPlayer player)
		{
			method_8("ShowAddFriendFrame", player);
		}

		public void CloseAddFriendFrame()
		{
			method_8("CloseAddFriendFrame");
		}

		public void ShowRemoveFriendPopup(BnetPlayer friend)
		{
			method_8("ShowRemoveFriendPopup", friend);
		}

		public void UpdateRAFButtonGlow()
		{
			method_8("UpdateRAFButtonGlow");
		}

		public void UpdateFSGButtonGlow()
		{
			method_8("UpdateFSGButtonGlow");
		}

		public void UpdateFlyoutButtonGlow()
		{
			method_8("UpdateFlyoutButtonGlow");
		}

		public List<GameObject> GetIgnoreListForWorldBounds()
		{
			return method_14<Class271<GameObject>>("GetIgnoreListForWorldBounds", Array.Empty<object>())?.method_25();
		}

		public void SetRAFButtonEnabled(bool enabled)
		{
			method_8("SetRAFButtonEnabled", enabled);
		}

		public void SetFSGButtonEnabled()
		{
			method_8("SetFSGButtonEnabled");
		}

		public void SetupFSGButtonAndFixFrameLength(bool enabled, float middleFrameScaleY, float middleShadowScaleY)
		{
			method_8("SetupFSGButtonAndFixFrameLength", enabled, middleFrameScaleY, middleShadowScaleY);
		}

		public void OpenFlyoutMenu()
		{
			method_8("OpenFlyoutMenu");
		}

		public void CloseFlyoutMenu()
		{
			method_8("CloseFlyoutMenu");
		}

		public void CreateItemsCamera()
		{
			method_8("CreateItemsCamera");
		}

		public void UpdateItemsList()
		{
			method_8("UpdateItemsList");
		}

		public void UpdateItemsCamera()
		{
			method_8("UpdateItemsCamera");
		}

		public void UpdateBackgroundCollider()
		{
			method_8("UpdateBackgroundCollider");
		}

		public void UpdateDropShadow()
		{
			method_8("UpdateDropShadow");
		}

		public void UpdateMyself()
		{
			method_8("UpdateMyself");
		}

		public void InitItems()
		{
			method_8("InitItems");
		}

		public void UpdateItems()
		{
			method_8("UpdateItems");
		}

		public void UpdateFriendItems()
		{
			method_8("UpdateFriendItems");
		}

		public void UpdateNearbyPlayerItems()
		{
			method_8("UpdateNearbyPlayerItems");
		}

		public void UpdateCurrentFiresideGatherings()
		{
			method_8("UpdateCurrentFiresideGatherings");
		}

		public void UpdateFoundFiresideGatherings()
		{
			method_8("UpdateFoundFiresideGatherings");
		}

		public void InitFiresideGatheringPlayers()
		{
			method_8("InitFiresideGatheringPlayers");
		}

		public void RemoveAllFiresideGatheringPlayers()
		{
			method_8("RemoveAllFiresideGatheringPlayers");
		}

		public FriendListBaseFriendFrame FindBaseFriendFrame(BnetPlayer friend)
		{
			return method_14<FriendListBaseFriendFrame>("FindBaseFriendFrame", new object[1] { friend });
		}

		public FriendListCurrentGameFrame FindCurrentGameFrame(BnetPlayer friend)
		{
			return method_14<FriendListCurrentGameFrame>("FindCurrentGameFrame", new object[1] { friend });
		}

		public FriendListFriendFrame FindFriendFrame(BnetPlayer friend)
		{
			return method_15<FriendListFriendFrame>("FindFriendFrame", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { friend });
		}

		public MobileFriendListItem CreateFriendFrame(BnetPlayer friend)
		{
			return method_14<MobileFriendListItem>("CreateFriendFrame", new object[1] { friend });
		}

		public MobileFriendListItem CreateNearbyPlayerFrame(BnetPlayer friend)
		{
			return method_14<MobileFriendListItem>("CreateNearbyPlayerFrame", new object[1] { friend });
		}

		public MobileFriendListItem CreateCurrentGameFrame(BnetPlayer friend)
		{
			return method_14<MobileFriendListItem>("CreateCurrentGameFrame", new object[1] { friend });
		}

		public MobileFriendListItem CreateRequestFrame(BnetInvitation invite)
		{
			return method_14<MobileFriendListItem>("CreateRequestFrame", new object[1] { invite });
		}

		public MobileFriendListItem CreateFSGPlayerFrame(BnetPlayer friend)
		{
			return method_14<MobileFriendListItem>("CreateFSGPlayerFrame", new object[1] { friend });
		}

		public MobileFriendListItem CreateFSGFooter(string text)
		{
			return method_14<MobileFriendListItem>("CreateFSGFooter", new object[1] { text });
		}

		public void UpdateAllHeaders()
		{
			method_8("UpdateAllHeaders");
		}

		public void UpdateAllHeaderBackgrounds()
		{
			method_8("UpdateAllHeaderBackgrounds");
		}

		public void UpdateRequestsHeader(FriendListItemHeader header)
		{
			method_8("UpdateRequestsHeader", header);
		}

		public void UpdateCurrentGamesHeader()
		{
			method_8("UpdateCurrentGamesHeader");
		}

		public void UpdateNearbyPlayersHeader(FriendListItemHeader header)
		{
			method_8("UpdateNearbyPlayersHeader", header);
		}

		public List<FriendListItem> GetFriendItems()
		{
			return method_14<Class270<FriendListItem>>("GetFriendItems", Array.Empty<object>())?.method_25();
		}

		public void UpdateFriendsHeader(FriendListItemHeader header)
		{
			method_8("UpdateFriendsHeader", header);
		}

		public void UpdateHeaderBackground(FriendListItemHeader itemHeader)
		{
			method_8("UpdateHeaderBackground", itemHeader);
		}

		public FriendListItemHeader FindHeader(MobileFriendListItem.TypeFlags type)
		{
			return method_14<FriendListItemHeader>("FindHeader", new object[1] { type });
		}

		public bool DoesHeaderExist(MobileFriendListItem.TypeFlags type)
		{
			return method_11<bool>("DoesHeaderExist", new object[1] { type });
		}

		public FriendListItemHeader FindOrAddHeader(MobileFriendListItem.TypeFlags type)
		{
			return method_14<FriendListItemHeader>("FindOrAddHeader", new object[1] { type });
		}

		public void OnHeaderSectionToggle(bool show, object userdata)
		{
			method_8("OnHeaderSectionToggle", show, userdata);
		}

		public bool RemoveItem(bool isHeader, MobileFriendListItem.TypeFlags type, object itemToRemove)
		{
			return method_11<bool>("RemoveItem", new object[3] { isHeader, type, itemToRemove });
		}

		public void AddItem(FriendListItem itemToAdd)
		{
			method_8("AddItem", itemToAdd);
		}

		public void SuspendItemsLayout()
		{
			method_8("SuspendItemsLayout");
		}

		public void ResumeItemsLayout()
		{
			method_8("ResumeItemsLayout");
		}

		public void ToggleEditFriendsMode()
		{
			method_8("ToggleEditFriendsMode");
		}

		public void ExitEditFriendsMode()
		{
			method_8("ExitEditFriendsMode");
		}

		public void SortAndRefreshTouchList()
		{
			method_8("SortAndRefreshTouchList");
		}

		public int ItemsSortCompare(FriendListItem item1, FriendListItem item2)
		{
			return method_11<int>("ItemsSortCompare", new object[2] { item1, item2 });
		}

		public void RegisterFriendEvents()
		{
			method_8("RegisterFriendEvents");
		}

		public void UnregisterFriendEvents()
		{
			method_8("UnregisterFriendEvents");
		}

		public void OnFriendsChanged(BnetFriendChangelist changelist, object userData)
		{
			method_8("OnFriendsChanged", changelist, userData);
		}

		public void OnNearbyPlayersChanged(BnetNearbyPlayerChangelist changelist, object userData)
		{
			method_8("OnNearbyPlayersChanged", changelist, userData);
		}

		public void HandleNearbyPlayersChanged()
		{
			method_8("HandleNearbyPlayersChanged");
		}

		public void DoPlayersChanged(BnetPlayerChangelist changelist)
		{
			method_8("DoPlayersChanged", changelist);
		}

		public void OnPlayersChanged(BnetPlayerChangelist changelist, object userData)
		{
			method_8("OnPlayersChanged", changelist, userData);
		}

		public void OnRequestNearbyFSGsResponse()
		{
			method_8("OnRequestNearbyFSGsResponse");
		}

		public void OnScenePreUnload(SceneMgr.Mode prevMode, PegasusScene prevScene, object userData)
		{
			method_8("OnScenePreUnload", prevMode, prevScene, userData);
		}

		public void OnFriendChallengeChanged(FriendChallengeEvent challengeEvent, BnetPlayer player, object userData)
		{
			method_8("OnFriendChallengeChanged", challengeEvent, player, userData);
		}

		public bool HandleKeyboardInput()
		{
			return method_11<bool>("HandleKeyboardInput", Array.Empty<object>());
		}

		public void OnAddFriendButtonReleased(UIEvent e)
		{
			method_8("OnAddFriendButtonReleased", e);
		}

		public void OnEditFriendsButtonReleased(UIEvent e)
		{
			method_8("OnEditFriendsButtonReleased", e);
		}

		public void OnRemoveFriendButtonReleased(UIEvent e)
		{
			method_8("OnRemoveFriendButtonReleased", e);
		}

		public void OnRAFButtonReleased(UIEvent e)
		{
			method_8("OnRAFButtonReleased", e);
		}

		public void OnRAFButtonOver(UIEvent e)
		{
			method_8("OnRAFButtonOver", e);
		}

		public void OnRAFButtonOut(UIEvent e)
		{
			method_8("OnRAFButtonOut", e);
		}

		public void OnFSGButtonReleased(UIEvent e)
		{
			method_8("OnFSGButtonReleased", e);
		}

		public bool OnRemoveFriendDialogShown(DialogBase dialog, object userData)
		{
			return method_11<bool>("OnRemoveFriendDialogShown", new object[2] { dialog, userData });
		}

		public void OnRemoveFriendPopupResponse(AlertPopup.Response response, object userData)
		{
			method_8("OnRemoveFriendPopupResponse", response, userData);
		}

		public void OnBaseFriendFrameReleased(UIEvent e)
		{
			method_8("OnBaseFriendFrameReleased", e);
		}

		public void OnFlyoutButtonReleased(UIEvent e)
		{
			method_8("OnFlyoutButtonReleased", e);
		}

		public void UpdateSelectedItem()
		{
			method_8("UpdateSelectedItem");
		}

		public void UpdateRAFState()
		{
			method_8("UpdateRAFState");
		}

		public void UpdateFSGState()
		{
			method_8("UpdateFSGState");
		}

		public void InitButtons()
		{
			method_8("InitButtons");
		}

		public bool GetShowHeaderSection(Option setoption)
		{
			return method_11<bool>("GetShowHeaderSection", new object[1] { setoption });
		}

		public void SetShowHeaderSection(Option sectionoption, bool show)
		{
			method_8("SetShowHeaderSection", sectionoption, show);
		}

		public Transform GetBottomRightBone()
		{
			return method_14<Transform>("GetBottomRightBone", Array.Empty<object>());
		}

		public void OnTemporaryAccountSignUpButtonPressed(UIEvent e)
		{
			method_8("OnTemporaryAccountSignUpButtonPressed", e);
		}
	}
}
